export const ArrayData = [
    {
        key: 1,
        name: "chunk",
        tags: "Array",
        remark: "分割数组",
        use: "_.chunk(array, [size=1])",
        argument: `
1.array (Array): 需要处理的数组;
2.[size=1] (number): 每个数组区块的长度
        `,
        return: "(Array): 返回一个包含拆分区块的新数组（注：相当于一个二维数组）。",
        description: "将数组（array）拆分成多个 size 长度的区块，并将这些区块组成一个新数组。 如果array 无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块。",
        case: `
_.chunk(['a', 'b', 'c', 'd'], 2);
// => [['a', 'b'], ['c', 'd']]
 
_.chunk(['a', 'b', 'c', 'd'], 3);
// => [['a', 'b', 'c'], ['d']]
`,
    },
    {
        key: 2,
        name: "compact",
        remark: "处理假值",
        use: "_.compact(array)",
        argument: `
array (Array): 待处理的数组
        `,
        return: "(Array): 返回过滤掉假值的新数组。",
        description: "创建一个新数组，包含原数组中所有的非假值元素。例如false, null,0, '', undefined, 和 NaN 都是被认为是“假值”。",
        case: `
_.compact([0, 1, false, 2, '', 3]);
// => [1, 2, 3]
        `,
    },
    {
        key: 3,
        name: "concat",
        remark: "拼接数组",
        use: "_.concat(array, [values])",
        argument: `
1.array (Array): 被连接的数组。
2.[values] (...*): 连接的值。
        `,
        return: "(Array): 返回连接后的新数组。",
        description: "创建一个新数组，将array与任何数组 或 值连接在一起。",
        case: ``,
    },
    {
        key: 4,
        name: "difference",
        remark: "排除数组指定值",
        use: "_.difference(array, [values])",
        argument: `
1.array (Array): 要检查的数组。
2.[values] (...Array): 排除的值。
        `,
        return: "(Array): 返回一个过滤值后的新数组。",
        description:
            "创建一个具有唯一array值的数组，每个值不包含在其他给定的数组中。（注：即创建一个新数组，这个数组中的值，为第一个数字（array 参数）排除了给定数组中的值。）该方法使用SameValueZero做相等比较。结果值的顺序是由第一个数组中的顺序确定。",
        case: ``,
    },
    {
        key: 5,
        name: "differenceBy",
        remark: "相当于执行第三个参数的方法遍历两个数组，得到结果进行处理。",
        use: "_.differenceBy(array, [values], [iteratee=_.identity])",
        argument: `
1.array (Array): 要检查的数组。
2.[values] (...Array): 排除的值。
3.[iteratee=_.identity](Array|Function|Object|string):iteratee 调用每个元素。
        `,
        return: "(Array): 返回一个过滤值后的新数组。",
        description:
            "这个方法类似_.difference ，除了它接受一个 iteratee （注：迭代器）， 调用array 和 values 中的每个元素以产生比较的标准。 结果值是从第一数组中选择。iteratee 会调用一个参数：(value)。（注：首先使用迭代器分别迭代array 和 values中的每个元素，返回的值作为比较值）。Note: 不像_.pullAllBy，这个方法会返回一个新数组。",
        case: `
_.differenceBy([3.1, 2.2, 1.3], [4.4, 2.5], Math.floor); => [3.1, 1.3]
        `,
    },
    {
        key: 6,
        name: "differenceWith",
        remark: "",
        use: "_.differenceWith(array, [values], [comparator])",
        argument: `
1.array (Array): 要检查的数组。
2.[values] (...Array): 排除的值。
3.[comparator] (Function): comparator 调用每个元素。
        `,
        return: "(Array): 返回一个过滤值后的新数组。",
        description: "这个方法类似_.difference ，除了它接受一个 comparator （注：比较器），它调用比较array，values中的元素。 结果值是从第一数组中选择。comparator 调用参数有两个：(arrVal, othVal)。",
        case: ``,
    },
    {
        key: 7,
        name: "drop",
        remark: "删除指定个数的元素",
        use: "_.drop(array, [n=1])",
        argument: `
1.array (Array): 要查询的数组。
2.[n=1] (number): 要去除的元素个数。
        `,
        return: "(Array): 返回array剩余切片。",
        description: "创建一个切片数组，去除array前面的n个元素。（n默认值为1。）",
        case: `
_.drop([1, 2, 3]);
// => [2, 3]

_.drop([1, 2, 3], 2);
// => [3]

_.drop([1, 2, 3], 5);
// => []

_.drop([1, 2, 3], 0);
// => [1, 2, 3]
        `,
    },
    {
        key: 8,
        name: "dropRight",
        remark: "删除数组尾部元素",
        use: "_.dropRight(array, [n=1]",
        argument: `
1.array (Array): 要查询的数组。
2.[n=1] (number): 要去除的元素个数。
        `,
        return: "(Array): 返回array剩余切片。",
        description: "创建一个切片数组，去除array尾部的n个元素。（n默认值为1。）",
        case: `
_.dropRight([1, 2, 3]);
// => [1, 2]

_.dropRight([1, 2, 3], 2);
// => [1]

_.dropRight([1, 2, 3], 5);
// => []

_.dropRight([1, 2, 3], 0);
// => [1, 2, 3]
        `,
    },
    {
        key: 9,
        name: "dropRightWhile",
        remark: "没理解",
        use: "_.dropRightWhile(array, [predicate=_.identity])",
        argument: `
1.array (Array): 要查询的数组。
2.[predicate=_.identity] (Function):这个函数会在每一次迭代调用。
        `,
        return: "(Array): 返回array剩余切片。",
        description: "创建一个切片数组，去除array中从 predicate 返回假值开始到尾部的部分。predicate 会传入3个参数： (value, index, array)。",
        case: `
var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];
 
_.dropRightWhile(users, function(o) { return !o.active; });
// => objects for ['barney']
 
// The _.matches iteratee shorthand.
_.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
// => objects for ['barney', 'fred']
 
// The _.matchesProperty iteratee shorthand.
_.dropRightWhile(users, ['active', false]);
// => objects for ['barney']
 
// The _.property iteratee shorthand.
_.dropRightWhile(users, 'active');
// => objects for ['barney', 'fred', 'pebbles']
        `,
    },
    {
        key: 10,
        name: "dropWhile",
        remark: "没理解",
        use: "_.dropWhile(array, [predicate=_.identity]",
        argument: `
1.array (Array): 要查询的数组。
2.[predicate=_.identity] (Function):这个函数会在每一次迭代调用。
        `,
        return: "(Array): 返回array剩余切片。",
        description: "xxxx",
        case: `
var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];
 
_.dropWhile(users, function(o) { return !o.active; });
// => objects for ['pebbles']
 
// The _.matches iteratee shorthand.
_.dropWhile(users, { 'user': 'barney', 'active': false });
// => objects for ['fred', 'pebbles']
 
// The _.matchesProperty iteratee shorthand.
_.dropWhile(users, ['active', false]);
// => objects for ['pebbles']
 
// The _.property iteratee shorthand.
_.dropWhile(users, 'active');
// => objects for ['barney', 'fred', 'pebbles']
        `,
    },
    {
        key: 11,
        name: "fill",
        remark: "数组填充",
        use: "_.fill(array, value, [start=0], [end=array.length])",
        argument: `
1.array (Array): 要填充改变的数组。
2.value (*): 填充给 array 的值。
3.[start=0] (number): 开始位置（默认0）。
4.[end=array.length] (number):结束位置（默认array.length）。
        `,
        return: "(Array): 返回 array。",
        description: "使用 value 值来填充（替换） array，从start位置开始, 到end位置结束（但不包含end位置）。Note: 这个方法会改变 array（注：不是创建新数组）。",
        case: `
var array = [1, 2, 3];

_.fill(array, 'a');
console.log(array);
// => ['a', 'a', 'a']

_.fill(Array(3), 2);
// => [2, 2, 2]

_.fill([4, 6, 8, 10], '*', 1, 3);
// => [4, '*', '*', 10]
        `,
    },
    {
        key: 12,
        name: "findIndex",
        remark: "搜索数组中符合条件的数据",
        use: "_.findIndex(array, [predicate=_.identity], [fromIndex=0])",
        argument: `
1.array (Array): 要搜索的数组。
2.[predicate=_.identity] (Array|Function|Object|string):这个函数会在每一次迭代调用。
3.[fromIndex=0] (number): The index to search from.
        `,
        return: "(number): 返回找到元素的 索引值（index），否则返回 -1。",
        description: "该方法类似_.find，区别是该方法返回第一个通过 predicate 判断为真值的元素的索引值（index），而不是元素本身。",
        case: `
var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];
 
_.findIndex(users, function(o) { return o.user == 'barney'; });
// => 0
 
// The _.matches iteratee shorthand.
_.findIndex(users, { 'user': 'fred', 'active': false });
// => 1
 
// The _.matchesProperty iteratee shorthand.
_.findIndex(users, ['active', false]);
// => 0
 
// The _.property iteratee shorthand.
_.findIndex(users, 'active');
// => 2
        `,
    },
    {
        key: 13,
        name: "findLastIndex",
        remark: "搜索数组中符合条件的数据",
        use: "_.findLastIndex(array, [predicate=_.identity], [fromIndex=array.length-1])",
        argument: `
1.array (Array): 要搜索的数组。
2.[predicate=_.identity](Array|Function|Object|string):这个函数会在每一次迭代调用。
3.[fromIndex=array.length-1] (number):The index to search from.
        `,
        return: "(number): 返回找到元素的 索引值（index），否则返回 -1。",
        description: "这个方式类似_.findIndex， 区别是它是从右到左的迭代集合array中的元素。",
        case: `
var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];
 
_.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
// => 2
 
// The _.matches iteratee shorthand.
_.findLastIndex(users, { 'user': 'barney', 'active': true });
// => 0
 
// The _.matchesProperty iteratee shorthand.
_.findLastIndex(users, ['active', false]);
// => 2
 
// The _.property iteratee shorthand.
_.findLastIndex(users, 'active');
// => 0
        `,
    },
    {
        key: 14,
        name: "head【_.first】",
        remark: "获取数组第一个元素",
        use: "_.head(array)",
        argument: `
array (Array): 要查询的数组
        `,
        return: "(*): 返回数组 array的第一个元素。",
        description: "获取数组 array 的第一个元素。",
        case: `
_.head([1, 2, 3]);
// => 1

_.head([]);
// => undefined
        `,
    },
    {
        key: 15,
        name: "flatten",
        remark: "减少一层数组嵌套，和flat函数类似",
        use: "_.flatten(array)",
        argument: `
array (Array): 需要减少嵌套层级的数组。
        `,
        return: "(Array): 返回减少嵌套层级后的新数组。",
        description: "减少一级array嵌套深度。",
        case: `
_.flatten([1, [2, [3, [4]], 5]]);
// => [1, 2, [3, [4]], 5]
        `,
    },
    {
        key: 16,
        name: "flattenDeep",
        remark: "嵌套数组转换为一维数组，和flatMap函数类似",
        use: "_.flattenDeep(array)",
        argument: `
array (Array): 需要处理的数组。
        `,
        return: "(Array): 返回一个的新一维数组。",
        description: "将array递归为一维数组。",
        case: `
_.flattenDeep([1, [2, [3, [4]], 5]]);
// => [1, 2, 3, 4, 5]
        `,
    },
    {
        key: 17,
        name: "flattenDepth",
        remark: "减少一层数组嵌套，和flat函数类似",
        use: "_.flattenDepth(array, [depth=1])",
        argument: `
1.array (Array): 需要减少嵌套层级的数组。
2.[depth=1] (number):最多减少的嵌套层级数。
        `,
        return: "(Array): 返回减少嵌套层级后的新数组。",
        description: "根据 depth 递归减少 array 的嵌套层级",
        case: `
var array = [1, [2, [3, [4]], 5]];

_.flattenDepth(array, 1);
// => [1, 2, [3, [4]], 5]

_.flattenDepth(array, 2);
// => [1, 2, 3, [4], 5]
        `,
    },
    {
        key: 18,
        name: "fromPairs",
        remark: "二维数组转对象",
        use: "_.fromPairs(pairs)",
        description: "与_.toPairs正好相反；这个方法返回一个由键值对pairs构成的对象。",
        argument: `
pairs (Array): 键值对pairs。
        `,
        return: "(Object): 返回一个新对象。",
        case: `
_.fromPairs([['fred', 30], ['barney', 40]]);
// => { 'fred': 30, 'barney': 40 }
        `,
    },
    {
        key: 19,
        name: "indexOf",
        remark: "",
        use: "_.indexOf(array, value, [fromIndex=0])",
        description: "使用SameValueZero 等值比较，返回首次 value 在数组array中被找到的 索引值， 如果 fromIndex 为负值，将从数组array尾端索引进行匹配。",
        argument: `
1.array (Array): 需要查找的数组。
2.value (*): 需要查找的值。
3.[fromIndex=0] (number): 开始查询的位置。
        `,
        return: "(number): 返回 值value在数组中的索引位置, 没有找到为返回-1。",
        case: `
_.indexOf([1, 2, 1, 2], 2);
// => 1
 
// Search from the fromIndex.
_.indexOf([1, 2, 1, 2], 2, 2);
// => 3
        `,
    },
    {
        key: 20,
        name: "initial",
        remark: "删除数组最后一个元素",
        use: "_.initial(array)",
        description: "获取数组array中除了最后一个元素之外的所有元素（注：去除数组array中的最后一个元素）。",
        argument: `
array (Array): 要查询的数组。
        `,
        return: "(Array): 返回截取后的数组array。",
        case: `
_.initial([1, 2, 3]);
// => [1, 2]
        `,
    },
    {
        key: 21,
        name: "intersection",
        remark: "求数组交集",
        use: "_.intersection([arrays])",
        description: "创建唯一值的数组，这个数组包含所有给定数组都包含的元素，使用SameValueZero进行相等性比较。（注：可以理解为给定数组的交集）",
        argument: `
[arrays] (...Array): 待检查的数组。
        `,
        return: "(Array): 返回一个包含所有传入数组交集元素的新数组。",
        case: `
_.intersection([2, 1], [4, 2], [1, 2]);
// => [2]
        `,
    },
    {
        key: 22,
        name: "intersectionBy",
        remark: "对处理后的数组求交集",
        use: "_.intersectionBy([arrays], [iteratee=_.identity])",
        description: "这个方法类似_.intersection，区别是它接受一个 iteratee 调用每一个arrays的每个值以产生一个值，通过产生的值进行了比较。结果值是从第一数组中选择。iteratee 会传入一个参数：(value)。",
        argument: `
1.[arrays] (...Array): 待检查的数组。
2.[iteratee=_.identity] (Array|Function|Object|string): iteratee（迭代器）调用每个元素。
        `,
        return: "(Array): 返回一个包含所有传入数组交集元素的新数组。",
        case: `
_.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
// => [2.1]
 
// The _.property iteratee shorthand.
_.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }]
        `,
    },
    {
        key: 23,
        name: "intersectionWith",
        remark: "求交集，结果值是从第一数组中选择",
        use: "_.intersectionWith([arrays], [comparator])",
        description: "这个方法类似_.intersection，区别是它接受一个 comparator 调用比较arrays中的元素。结果值是从第一数组中选择。comparator 会传入两个参数：(arrVal, othVal)。",
        argument: `
1.[arrays] (...Array): 待检查的数组。
2.[comparator] (Function): comparator（比较器）调用每个元素。
        `,
        return: "(Array): 返回一个包含所有传入数组交集元素的新数组。",
        case: `
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];

_.intersectionWith(objects, others, _.isEqual);
// => [{ 'x': 1, 'y': 2 }]
        `,
    },
    {
        key: 24,
        name: "join",
        remark: "数组拼接",
        use: "_.join(array, [separator=','])",
        description: "将 array 中的所有元素转换为由 separator 分隔的字符串。",
        argument: `
1.array (Array): 要转换的数组。
2.[separator=','] (string): 分隔元素。
        `,
        return: "(string): 返回连接字符串。",
        case: `
_.join(['a', 'b', 'c'], '~');
// => 'a~b~c'
        `,
    },
    {
        key: 25,
        name: "last",
        remark: "获取数组最后一个元素",
        use: "_.last(array)",
        description: "获取array中的最后一个元素。",
        argument: `
array (Array): 要检索的数组。
        `,
        return: "(*): 返回array中的最后一个元素",
        case: `
_.last([1, 2, 3]);
// => 3
        `,
    },
    {
        key: 26,
        name: "lastIndexOf",
        remark: "从右到左遍历array的元素进行搜索",
        use: "_.lastIndexOf(array, value, [fromIndex=array.length-1])",
        description: "这个方法类似_.indexOf ，区别是它是从右到左遍历array的元素。",
        argument: `
1.array (Array): 要搜索的数组。
2.value (*): 要搜索的值。
3.[fromIndex=array.length-1] (number): 开始搜索的索引值。
        `,
        return: "(number): 返回匹配值的索引值，否则返回 -1。",
        case: `
_.lastIndexOf([1, 2, 1, 2], 2);
// => 3
 
// Search from the fromIndex.
_.lastIndexOf([1, 2, 1, 2], 2, 2);
// => 1
        `,
    },
    {
        key: 27,
        name: "nth",
        remark: "获取array数组的第n个元素",
        use: "_.nth(array, [n=0])",
        description: "获取array数组的第n个元素。如果n为负数，则返回从数组结尾开始的第n个元素。",
        argument: `
1.array (Array): 要查询的数组。
2.[n=0] (number): 要返回元素的索引值。
        `,
        return: "(*): 获取array数组的第n个元素。",
        case: `
var array = ['a', 'b', 'c', 'd'];

_.nth(array, 1);
// => 'b'

_.nth(array, -2);
// => 'c';
        `,
    },
    {
        key: 28,
        name: "pull",
        remark: "在数组中删除指定元素",
        use: "_.pull(array, [values])",
        description: "移除数组array中所有和给定值相等的元素，使用SameValueZero 进行全等比较。注意： 和_.without 方法不同，这个方法会改变数组。使用_.remove 从一个数组中移除元素。",
        argument: `
1.array (Array): 要修改的数组。
2.[values] (...*): 要删除的值。
        `,
        return: "(Array): 返回 array.",
        case: `
var array = [1, 2, 3, 1, 2, 3];

_.pull(array, 2, 3);
console.log(array);
// => [1, 1]
        `,
    },
    {
        key: 29,
        name: "pullAll",
        remark: "在数组中删除指定元素，感觉和pull类似",
        use: "_.pullAll(array, values)",
        description: "这个方法类似_.pull，区别是这个方法接收一个要移除值的数组。Note: 不同于_.difference, 这个方法会改变数组 array。",
        argument: `
1.array (Array): 要修改的数组。
2.values (Array): 要移除值的数组。
        `,
        return: "(Array): 返回 array。",
        case: `
var array = [1, 2, 3, 1, 2, 3];

_.pullAll(array, [2, 3]);
console.log(array);
// => [1, 1]
        `,
    },
    {
        key: 30,
        name: "pullAllBy",
        remark: "先处理数组然后再进行移除",
        use: "_.pullAllBy(array, values, [iteratee=_.identity])",
        description:
            "这个方法类似于_.pullAll ，区别是这个方法接受一个 iteratee（迭代函数） 调用 array 和 values的每个值以产生一个值，通过产生的值进行了比较。iteratee 会传入一个参数： (value)。Note: 不同于_.differenceBy, 这个方法会改变数组 array。",
        argument: `
1.array (Array): 要修改的数组。
2.values (Array): 要移除值的数组。
3.[iteratee=_.identity] (Array|Function|Object|string): iteratee（迭代器）调用每个元素。
        `,
        return: "(Array): 返回 array.",
        case: `
var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];

_.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
console.log(array);
// => [{ 'x': 2 }]
        `,
    },
    {
        key: 31,
        name: "pullAllWith",
        remark: "先比较再删除",
        use: "_.pullAllWith(array, values, [comparator])",
        description: "这个方法类似于_.pullAll，区别是这个方法接受 comparator 调用array中的元素和values比较。comparator 会传入两个参数：(arrVal, othVal)。注意: 和_.differenceWith 不同, 这个方法会改变数组 array。",
        argument: `
1.array (Array): 要修改的数组。
2.values (Array): 要移除值的数组。
3.[comparator] (Function): comparator（比较器）调用每个元素。
        `,
        return: "(Array): 返回 array。",
        case: `
var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];

_.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
console.log(array);
// => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
        `,
    },
    {
        key: 32,
        name: "pullAt",
        remark: "删除数组指定元素",
        use: "_.pullAt(array, [indexes])",
        description: "根据索引 indexes，移除array中对应的元素，并返回被移除元素的数组。Note: 和_.at不同, 这个方法会改变数组 array。",
        argument: `
1.array (Array): 要修改的数组。
2.[indexes] (...(number|number[])): 要移除元素的索引。
        `,
        return: "(Array): 返回移除元素组成的新数组。",
        case: `
var array = [5, 10, 15, 20];
var evens = _.pullAt(array, 1, 3);

console.log(array);
// => [5, 15]

console.log(evens);
// => [10, 20]
        `,
    },
    {
        key: 33,
        name: "remove",
        remark: "先处理后移除",
        use: "_.remove(array, [predicate=_.identity])",
        description:
            "移除数组中predicate（断言）返回为真值的所有元素，并返回移除元素组成的数组。predicate（断言） 会传入3个参数： (value, index, array)。Note: 和_.filter不同, 这个方法会改变数组 array。使用_.pull来根据提供的value值从数组中移除元素。",
        argument: `
1.array (Array): 要修改的数组。
2.[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
        `,
        return: "(Array): 返回移除元素组成的新数组。",
        case: `
var array = [1, 2, 3, 4];
var evens = _.remove(array, function(n) {
  return n % 2 == 0;
});

console.log(array);
// => [1, 3]

console.log(evens);
// => [2, 4]
        `,
    },
    {
        key: 34,
        name: "reverse",
        remark: "反转数组",
        use: "_.reverse(array)",
        description: "反转array，使得第一个元素变为最后一个元素，第二个元素变为倒数第二个元素，依次类推。Note: 这个方法会改变原数组 array，基于Array#reverse.",
        argument: `
array (Array): 要修改的数组。
        `,
        return: "(Array): 返回 array.",
        case: `
var array = [1, 2, 3];

_.reverse(array);
// => [3, 2, 1]

console.log(array);
// => [3, 2, 1]
        `,
    },
    {
        key: 35,
        name: "slice",
        remark: "裁剪数组",
        use: "_.slice(array, [start=0], [end=array.length])",
        description: "裁剪数组array，从 start 位置开始到end结束，但不包括 end 本身的位置。Note: 这个方法用于代替Array#slice 来确保数组正确返回。",
        argument: `
1.array (Array): 要裁剪数组。
2.[start=0] (number): 开始位置。
3.[end=array.length] (number): 结束位置。
        `,
        return: "(Array): 返回 数组array 裁剪部分的新数组。",
        case: `
        `,
    },
    {
        key: 36,
        name: "sortedIndex",
        remark: "返回目标值插在数组哪个位置",
        use: "_.sortedIndex(array, value)",
        description: "使用二进制的方式检索来决定 value值 应该插入到数组中 尽可能小的索引位置，以保证array的排序。",
        argument: `
1.array (Array): 要检查的排序数组。
2.value (*): 要评估的值。
        `,
        return: "(number): 返回 value值 应该在数组array中插入的索引位置 index。",
        case: `
_.sortedIndex([30, 50], 40);
// => 1
        `,
    },
    {
        key: 37,
        name: "sortedIndexBy",
        remark: "先处理数组再计算插入在哪里",
        use: "_.sortedIndexBy(array, value, [iteratee=_.identity])",
        description: "这个方法类似_.sortedIndex ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）元素，返回结果和value 值比较来计算排序。iteratee 会传入一个参数：(value)。",
        argument: `
1.array (Array): 要检查的排序数组。
2.value (*): 要评估的值。
3.[iteratee=_.identity] (Array|Function|Object|string): 迭代函数，调用每个元素。
        `,
        return: "(number): 返回 value值 应该在数组array中插入的索引位置 index。",
        case: `
var objects = [{ 'x': 4 }, { 'x': 5 }];
 
_.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
// => 0
 
// The _.property iteratee shorthand.
_.sortedIndexBy(objects, { 'x': 4 }, 'x');
// => 0
        `,
    },
    {
        key: 38,
        name: "sortedIndexOf",
        remark: "在数组中搜索值",
        use: "_.sortedIndexOf(array, value)",
        description: "这个方法类似_.indexOf，除了它是在已经排序的数组array上执行二进制检索。",
        argument: `
1.array (Array): 要搜索的数组。
2.value (*): 搜索的值。
        `,
        return: "(number): 返回匹配值的索引位置，否则返回 -1。",
        case: `
_.sortedIndexOf([4, 5, 5, 5, 6], 5);
// => 1
        `,
    },
    {
        key: 39,
        name: "sortedLastIndex",
        remark: "",
        use: "_.sortedLastIndex(array, value)",
        description: "此方法类似于_.sortedIndex，除了 它返回 value值 在 array 中尽可能大的索引位置（index）。",
        argument: `
1.array (Array): 要检查的排序数组。
2.value (*): 要评估的值。
        `,
        return: "(number): 返回 value值 应该在数组array中插入的索引位置 index。",
        case: `
_.sortedLastIndex([4, 5, 5, 5, 6], 5);
// => 4
        `,
    },
    {
        key: 40,
        name: "sortedLastIndexBy",
        remark: "先处理数组数据，处理完成后进行排序",
        use: "_.sortedLastIndexBy(array, value, [iteratee=_.identity])",
        description: "这个方法类似_.sortedLastIndex ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）元素，返回结果和value 值比较来计算排序。iteratee 会传入一个参数：(value)。",
        argument: `
1.array (Array): 要检查的排序数组。
2.value (*): 要评估的值。
3.[iteratee=_.identity] (Array|Function|Object|string): 迭代函数，调用每个元素。
        `,
        return: "(number): 返回 value值 应该在数组array中插入的索引位置 index。",
        case: `
var objects = [{ 'x': 4 }, { 'x': 5 }];
 
_.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
// => 1
 
// The _.property iteratee shorthand.
_.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
// => 1       
        `,
    },
    {
        key: 41,
        name: "sortedLastIndexOf",
        remark: "在数组中找到对应的值返回索引",
        use: "_.sortedLastIndexOf(array, value)",
        description: "这个方法类似_.lastIndexOf，除了它是在已经排序的数组array上执行二进制检索。",
        argument: `
1.array (Array): 要搜索的数组。
2.value (*): 搜索的值。
        `,
        return: "(number): 返回匹配值的索引位置，否则返回 -1。",
        case: `
_.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
// => 3
`,
    },
    {
        key: 42,
        name: "sortedUniq",
        remark: "去重排序",
        use: "_.sortedUniq(array)",
        description: "这个方法类似_.uniq，除了它会优化排序数组。",
        argument: `
array (Array): 要检查的数组。
        `,
        return: "(Array): 返回一个新的不重复的数组。",
        case: `
_.sortedUniq([1, 1, 2]);
// => [1, 2]
        `,
    },
    {
        key: 43,
        name: "sortedUniqBy",
        remark: "先处理数组再排序",
        use: "_.sortedUniqBy(array, [iteratee])",
        description: "这个方法类似_.uniqBy，除了它会优化排序数组。",
        argument: `
1.array (Array): 要检查的数组。
2.[iteratee] (Function): 迭代函数，调用每个元素。
        `,
        return: "(Array): 返回一个新的不重复的数组。",
        case: `
_.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
// => [1.1, 2.3]
        `,
    },
    {
        key: 44,
        name: "tail",
        remark: "删除数组第一个元素返回其他元素",
        use: "_.tail(array)",
        description: "获取除了array数组第一个元素以外的全部元素。",
        argument: `
array (Array): 要检索的数组。
        `,
        return: "(Array): 返回 array 数组的切片（除了array数组第一个元素以外的全部元素）。",
        case: `
_.tail([1, 2, 3]);
// => [2, 3]
        `,
    },
    {
        key: 45,
        name: "take",
        remark: "截取数组中n个元素",
        use: "_.take(array, [n=1])",
        description: "创建一个数组切片，从array数组的起始元素开始提取n个元素。",
        argument: `
1.array (Array): 要检索的数组。
2.[n=1] (number): 要提取的元素个数。
        `,
        return: "(Array): 返回 array 数组的切片（从起始元素开始n个元素）。",
        case: `
_.take([1, 2, 3]);
// => [1]

_.take([1, 2, 3], 2);
// => [1, 2]

_.take([1, 2, 3], 5);
// => [1, 2, 3]

_.take([1, 2, 3], 0);
// => []
        `,
    },
    {
        key: 46,
        name: "takeRight",
        remark: "从数组末尾截取n个元素",
        use: "_.takeRight(array, [n=1])",
        description: "创建一个数组切片，从array数组的最后一个元素开始提取n个元素。",
        argument: `
1.array (Array): 要检索的数组。
2.[n=1] (number): 要提取的元素个数。
        `,
        return: "(Array): 返回 array 数组的切片（从结尾元素开始n个元素）。",
        case: `
_.takeRight([1, 2, 3]);
// => [3]

_.takeRight([1, 2, 3], 2);
// => [2, 3]

_.takeRight([1, 2, 3], 5);
// => [1, 2, 3]

_.takeRight([1, 2, 3], 0);
// => []
        `,
    },
    {
        key: 47,
        name: "takeRightWhile",
        remark: "对数组末尾进行截取直到不符合规则",
        use: "_.takeRightWhile(array, [predicate=_.identity])",
        description: "从array数组的最后一个元素开始提取元素，直到 predicate 返回假值。predicate 会传入三个参数： (value, index, array)。",
        argument: `
1.array (Array): 要检索的数组。
2.[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
        `,
        return: "(Array): 返回 array 数组的切片。",
        case: `
var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];
 
_.takeRightWhile(users, function(o) { return !o.active; });
// => objects for ['fred', 'pebbles']
 
// The _.matches iteratee shorthand.
_.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
// => objects for ['pebbles']
 
// The _.matchesProperty iteratee shorthand.
_.takeRightWhile(users, ['active', false]);
// => objects for ['fred', 'pebbles']
 
// The _.property iteratee shorthand.
_.takeRightWhile(users, 'active');
// => []
        `,
    },
    {
        key: 48,
        name: "takeWhile",
        remark: "对数组开始进行截取直到不符合规则",
        use: "_.takeWhile(array, [predicate=_.identity])",
        description: "从array数组的起始元素开始提取元素，，直到 predicate 返回假值。predicate 会传入三个参数： (value, index, array)。",
        argument: `
1.array (Array): 需要处理的数组
2.[predicate=_.identity] (Array|Function|Object|string): 每次迭代调用的函数。
        `,
        return: "(Array): 返回 array 数组的切片。",
        case: `
var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false},
  { 'user': 'pebbles', 'active': true }
];
 
_.takeWhile(users, function(o) { return !o.active; });
// => objects for ['barney', 'fred']
 
// The _.matches iteratee shorthand.
_.takeWhile(users, { 'user': 'barney', 'active': false });
// => objects for ['barney']
 
// The _.matchesProperty iteratee shorthand.
_.takeWhile(users, ['active', false]);
// => objects for ['barney', 'fred']
 
// The _.property iteratee shorthand.
_.takeWhile(users, 'active');
// => []
        `,
    },
    {
        key: 49,
        name: "union",
        remark: "排序去重",
        use: "_.union([arrays])",
        description: "创建一个按顺序排列的唯一值的数组。所有给定数组的元素值使用SameValueZero做等值比较。（注： arrays（数组）的并集，按顺序返回，返回数组的元素是唯一的）",
        argument: `
[arrays] (...Array): 要检查的数组。
        `,
        return: "(Array): 返回一个新的联合数组。",
        case: `
_.union([2], [1, 2]);
// => [2, 1]
        `,
    },
    {
        key: 50,
        name: "unionBy",
        remark: "先处理数组再进行排序去重",
        use: "_.unionBy([arrays], [iteratee=_.identity])",
        description: "这个方法类似_.union ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）的每个元素以产生唯一性计算的标准。iteratee 会传入一个参数：(value)。",
        argument: `
1.[arrays] (...Array): 要检查的数组。
2.[iteratee=_.identity] (Array|Function|Object|string): 迭代函数，调用每个元素。
        `,
        return: "(Array): 返回一个新的联合数组。",
        case: `
_.unionBy([2.1], [1.2, 2.3], Math.floor);
// => [2.1, 1.2]
 
// The _.property iteratee shorthand.
_.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]
        `,
    },
    {
        key: 51,
        name: "unionWith",
        remark: "对象数组去重",
        use: "_.unionWith([arrays], [comparator])",
        description: "这个方法类似_.union， 除了它接受一个 comparator 调用比较arrays数组的每一个元素。 comparator 调用时会传入2个参数： (arrVal, othVal)。",
        argument: `
1.[arrays] (...Array): 要检查的数组。
2.[comparator] (Function): 比较函数，调用每个元素。
        `,
        return: "(Array): 返回一个新的联合数组。",
        case: `
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];

_.unionWith(objects, others, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
        `,
    },
    {
        key: 52,
        name: "uniq",
        remark: "创建一个去重后的array数组副本。",
        use: "_.uniq(array)",
        description: "创建一个去重后的array数组副本。使用了SameValueZero 做等值比较。只有第一次出现的元素才会被保留。",
        argument: `
array (Array): 要检查的数组。
        `,
        return: "(Array): 返回新的去重后的数组。",
        case: `
_.uniq([2, 1, 2]);
// => [2, 1]
        `,
    },
    {
        key: 53,
        name: "uniqBy",
        remark: "数组处理后去重",
        use: "_.uniqBy(array, [iteratee=_.identity])",
        description: "这个方法类似_.uniq ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）的每个元素以产生唯一性计算的标准。iteratee 调用时会传入一个参数：(value)。",
        argument: `
1.array (Array): 要检查的数组。
2.[iteratee=_.identity] (Array|Function|Object|string): 迭代函数，调用每个元素。
        `,
        return: "(Array): 返回新的去重后的数组。",
        case: `
_.uniqBy([2.1, 1.2, 2.3], Math.floor);
// => [2.1, 1.2]

// The _.property iteratee shorthand.
_.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]
        `,
    },
    {
        key: 54,
        name: "uniqWith",
        remark: "迭代数组进行比较，然后去重",
        use: "_.uniqWith(array, [comparator])",
        description: "这个方法类似_.uniq， 除了它接受一个 comparator 调用比较arrays数组的每一个元素。 comparator 调用时会传入2个参数： (arrVal, othVal)。",
        argument: `
1.array (Array): 要检查的数组。
2.[comparator] (Function): 比较函数，调用每个元素。
        `,
        return: "(Array): 返回新的去重后的数组。",
        case: `
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];

_.uniqWith(objects, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
        `,
    },
    {
        key: 55,
        name: "unzip",
        remark: "分类划分",
        use: "_.unzip(array)",
        description: "这个方法类似于_.zip，除了它接收分组元素的数组，并且创建一个数组，分组元素到打包前的结构。（：返回数组的第一个元素包含所有的输入数组的第一元素，第一个元素包含了所有的输入数组的第二元素，依此类推。）",
        argument: `
array (Array): 要处理的分组元素数组。
        `,
        return: "(Array): 返回重组元素的新数组。",
        case: `
var zipped = _.zip(['fred', 'barney'], [30, 40], [true, false]);
// => [['fred', 30, true], ['barney', 40, false]]

_.unzip(zipped);
// => [['fred', 'barney'], [30, 40], [true, false]]
        `,
    },
    {
        key: 56,
        name: "unzipWith",
        remark: "处理分类划分的数组数据",
        use: "_.unzipWith(array, [iteratee=_.identity])",
        description: "此方法类似于_.unzip，除了它接受一个iteratee指定重组值应该如何被组合。iteratee 调用时会传入每个分组的值： (...group)。",
        argument: `
1.array (Array): 要处理的分组元素数组。
2.[iteratee=_.identity] (Function): 这个函数用来组合重组的值。
        `,
        return: "(Array): 返回重组元素的新数组。",
        case: `
var zipped = _.zip([1, 2], [10, 20], [100, 200]);
// => [[1, 10, 100], [2, 20, 200]]

_.unzipWith(zipped, _.add);
// => [3, 30, 300]
        `,
    },
    {
        key: 57,
        name: "without",
        remark: "删除数组中指定数据",
        use: "_.without(array, [values])",
        description: "创建一个剔除所有给定值的新数组，剔除值的时候，使用SameValueZero做相等比较。注意: 不像_.pull, 这个方法会返回一个新数组。",
        argument: `
1.array (Array): 要检查的数组。
2.[values] (...*): 要剔除的值。
        `,
        return: "(Array): 返回过滤值后的新数组。",
        case: `
_.without([2, 1, 2, 3], 1, 2);
// => [3]
        `,
    },
    {
        key: 58,
        name: "xor",
        remark: "数组取交集后去除其并集",
        use: "_.xor([arrays])",
        description: "创建一个给定数组唯一值的数组，使用symmetric difference做等值比较。返回值的顺序取决于他们数组的出现顺序。",
        argument: `
[arrays] (...Array): 要检查的数组。
        `,
        return: "(Array): 返回过滤值后的新数组。",
        case: `
_.xor([2, 1], [2, 3]);
// => [1, 3]
        `,
    },
    {
        key: 59,
        name: "xorBy",
        remark: "先处理数组，然后取交集后去除其并集",
        use: "_.xorBy([arrays], [iteratee=_.identity])",
        description: "这个方法类似_.xor ，除了它接受 iteratee（迭代器），这个迭代器 调用每一个 arrays（数组）的每一个值，以生成比较的新值。iteratee 调用一个参数：(value).",
        argument: `
1.[arrays] (...Array): 要检查的数组。
2.[iteratee=_.identity] (Array|Function|Object|string): 调用每一个元素的迭代函数。
        `,
        return: "(Array): 返回过滤值后的新数组。",
        case: `
_.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
// => [1.2, 3.4]
 
// The _.property iteratee shorthand.
_.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 2 }]
        `,
    },
    {
        key: 60,
        name: "xorWith",
        remark: "先比较数组，然后取交集后去除其并集",
        use: "_.xorWith([arrays], [comparator])",
        description: "该方法是像_.xor，除了它接受一个 comparator ，以调用比较数组的元素。 comparator 调用2个参数：(arrVal, othVal).",
        argument: `
1.[arrays] (...Array): 要检查的数组。
2.[comparator] (Function): 调用每一个元素的比较函数。
        `,
        return: "(Array): 返回过滤值后的新数组。",
        case: `
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];

_.xorWith(objects, others, _.isEqual);
// => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
        `,
    },
    {
        key: 61,
        name: "zip",
        remark: "对二维数组的每一项设置一个数组",
        use: "_.zip([arrays])",
        description: "创建一个分组元素的数组，数组的第一个元素包含所有给定数组的第一个元素，数组的第二个元素包含所有给定数组的第二个元素，以此类推。",
        argument: `
[arrays] (...Array): 要处理的数组。
        `,
        return: "(Array): 返回分组元素的新数组。",
        case: `
_.zip(['fred', 'barney'], [30, 40], [true, false]);
// => [['fred', 30, true], ['barney', 40, false]]
        `,
    },
    {
        key: 62,
        name: "zipObject",
        remark: "二维数组转对象属性",
        use: "_.zipObject([props=[]], [values=[]])",
        description: "这个方法类似_.fromPairs，除了它接受2个数组，第一个数组中的值作为属性标识符（属性名），第二个数组中的值作为相应的属性值。",
        argument: `
1.[props=[]] (Array): The property identifiers.
2.[values=[]] (Array): The property values.
        `,
        return: "(Object): Returns the new object.",
        case: `
_.zipObject(['a', 'b'], [1, 2]);
// => { 'a': 1, 'b': 2 }
        `,
    },
    {
        key: 63,
        name: "zipObjectDeep",
        remark: "二维数组转对象属性可以递归对象属性",
        use: "_.zipObjectDeep([props=[]], [values=[]])",
        description: "这个方法类似_.zipObject，除了它支持属性路径。",
        argument: `
1.[props=[]] (Array): 属性标识符（属性名）。
2.[values=[]] (Array): 属性值。
        `,
        return: "(Object): 返回新对象。",
        case: `、
_.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
// => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
        `,
    },
    {
        key: 64,
        name: "zipWith",
        remark: "先转换然后按照迭代器进行处理",
        use: "_.zipWith([arrays], [iteratee=_.identity])",
        description: "这个方法类似于_.zip，不同之处在于它接受一个 iteratee（迭代函数），来 指定分组的值应该如何被组合。 该iteratee调用每个组的元素： (...group).",
        argument: `
1.[arrays] (...Array): 要处理的数组。
2.[iteratee=_.identity] (Function): 函数用来组合分组的值。
        `,
        return: "(Array): 返回分组元素的新数组。",
        case: `
_.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
  return a + b + c;
});
// => [111, 222]
        `,
    },
];
